/* =============================================================
 * object-utils.js v1.1.0
 * =============================================================
 * Original written by Ysy
 * =============================================================
 * Date 15/06/2021
 * ============================================================ */

"use strict";
let ObjectUtils = {
    /**
     * 判断对象是否为空
     * @param object 需要判断的对象
     * @returns {boolean}
     */
    isEmpty: function (object) {
        if (object && !Object.is(Object.keys(object).length, 0)) return false;

        return true;
    },

    /**
     * 清空对象属性值
     * @param object 需要清空属性值的对象
     */
    clear: function (object) {
        Object.keys(object).forEach(key => (object[key] = ""));
    },

    /**
     * 对象属性去除空串
     * @param object  需要去除空串的对象
     */
    trim: function (object) {
        Object.keys(object).forEach(key => {
            let value = object[key];
            if (!value) return;

            if (this.isObject(value)) {
                this.objectTrim(value);
            } else if (!StringUtils.isString(value)) {
                return;
            } else {
                return object[key] = value.trim();
            }
        });
    },

    /**
     * 判断两个对象属性、属性值完全相等
     * @param object1
     * @param object2
     * @returns {boolean}
     */
    equals: function (object1, object2) {
        if (!CommonUtils.isObject(object1) || !CommonUtils.isObject(object2)) return false;

        // 判断两个对象的属性长度
        if (!Object.is(Object.keys(object1).length, Object.keys(object2).length)) return false;

        // 根据属性键值取属性值
        for (let keys in object1) {
            // 判断object1的键值，在object2中是否存在，不存在，返回false
            if (!object2.hasOwnProperty(keys)) return false;

            if (CommonUtils.isObject(object1[keys]) && CommonUtils.isObject(object2[keys])) {// 如果都为对象  继续递归判断
                if (!this.equals(object1[keys], object2[keys])) return false;
            } else if (!Object.is(object1[keys], object2[keys])) {
                return false;
            }
        }
        return true;
    },

    /**
     * @Descripttion: 找出两个对象不同的属性
     * @Author: Ysy
     * @Date: 2021-08-18 13:55:59
     * @param  object1
     * @param  object2
     * @return 
     */    
    findDiff: function (object1, object2) {
        let diff = {};
        if (!CommonUtils.isObject(object1) || !CommonUtils.isObject(object2)) return diff;

        // 根据属性键值取属性值
        for (let key in object1) {
            // 判断object1的键值，在object2中是否存在，不存在，复制属性给新对象
            if (!object2.hasOwnProperty(key)) {
                diff[key] = [object1[key], null];
                continue;
            }

            // 判断数据类型是否一致
            if (Object.is(typeof object1[key], typeof object2[key])) {
                diff[key] = [object1[key], object2[key]];
                continue;
            }

            if (CommonUtils.isObject(object1[key]) && CommonUtils.isObject(object2[key])) {// 如果都为对象  继续递归判断
                diff[key] = this.findDiff(object1[key], object2[key]);
            } else if (!Object.is(object1[key], object2[key])) {
                diff[key] = [object1[key], object2[key]];
            }
        }
        
        return diff;
    },

    /**
     * @Author Ysy
     * @Description // 找出两个对象的不同之处  返回key值
     * @Date 14:21 2021/8/18
     * @param object1/object2/
     **/
    findDiffKey: function (object1, object2) {
        let diff = [];
        if (!CommonUtils.isObject(object1) || !CommonUtils.isObject(object2)) return diff;

        // 根据属性键值取属性值
        for (let key in object1) {
            // 判断object1的键值，在object2中是否存在，不存在，复制属性给新对象
            if (!object2.hasOwnProperty(key)) {
                diff.push(key);
                continue;
            }

            // 判断数据类型是否一致
            if (!Object.is(typeof object1[key], typeof object2[key])) {
                diff.push(key);
                continue;
            }

            if (CommonUtils.isObject(object1[key]) && CommonUtils.isObject(object2[key])) {// 如果都为对象  判断值是否相等
                if (!this.equals(object1[key], object2[key])) {
                    diff.push(key);
                }
            } else if (!Object.is(object1[key], object2[key])) {
                diff.push(key);
            }
        }

        return diff;
    },

    /**
     * @Descripttion: js 简单深拷贝
     * @Author: Ysy
     * @Date: 2021-07-30 17:09:46
     * @param {*} object
     * @return {*}
     */
    deepClone: function (target) {
        // 定义一个变量
        let result;

        // 如果当前需要深拷贝的是一个对象的话
        if (typeof target === "object") {
            // 如果是一个数组的话
            if (Array.isArray(target)) {
                result = []; // 将result赋值为一个数组，并且执行遍历
                for (let i in target) {
                    // 递归克隆数组中的每一项
                    result.push(this.deepClone(target[i]))
                }
            } else if (target === null) {// 判断如果当前的值是null的话；直接赋值为null
                result = null;
            } else if (target.constructor === RegExp) { // 判断如果当前的值是一个RegExp对象的话，直接赋值    
                result = target;
            } else {// 否则是普通对象，直接for in循环，递归赋值对象的所有值
                result = {};
                for (let i in target) {
                    result[i] = this.deepClone(target[i]);
                }
            }
        } else {// 如果不是对象的话，就是基本数据类型，那么直接赋值
            result = target;
        }
        
        // 返回最终结果
        return result;
    }
};

